#!/bin/bash
#
# GrabarParqueT
#


#########----- Declaracion de Variables ------#######

COMANDO_LOGUEART="./LoguearT.sh"
COMANDO_MOVERT="./MoverT.sh"

DIR_INST_RECIBIDAS="${GRUPO}/inst_recibidas/"
DIR_INST_PROCESADAS="${GRUPO}/inst_procesadas/"
DIR_INST_RECHAZADAS="${GRUPO}/inst_rechazadas/"
DIR_INST_ORDENADAS="${GRUPO}/inst_ordenadas/"
DIR_PARQUE_INSTALADO="${GRUPO}/parque_instalado/"
DIR_MAESTROS="${MAEDIR}/"
MAESTRO_CLIENTE="cli.mae"
MAESTRO_PRODUCTO="prod.mae"


REGEX_FECHA="[[:digit:]]\{4\}-[[:digit:]]\{2\}-[[:digit:]]\{2\}"    #fecha del tipo AAAA-MM-DD
REGEX_DECIMAL="[[:digit:]]\{1,4\}" #Decimal de 1 a 4 cifras
ITEM_NAME=""


let CANT_ARCHIVOS_RECIBIDOS=0
let CANT_ARCHIVOS_ORDENADOS=0
let CANT_ARCHIVOS_DUPLICADOS=0
let CANT_BLOQUES_ANALIZADOS=0
let CANT_BLOQUES_RECHAZADOS=0
let CANT_BLOQUES_VALIDOS=0
let CANT_REGISTROS_LEIDOS=0
let CANT_REGISTROS_RECHAZADOS=0
let CANT_REGISTROS_VALIDOS=0
SUCURSAL_ID=""
########------ Funciones Utiles -------#########



inicializo_variables(){
COMANDO_LOGUEART="./LoguearT.sh"
COMANDO_MOVERT="./MoverT.sh"

DIR_INST_RECIBIDAS="${GRUPO}/inst_recibidas/"
DIR_INST_PROCESADAS="${GRUPO}/inst_procesadas/"
DIR_INST_RECHAZADAS="${GRUPO}/inst_rechazadas/"
DIR_INST_ORDENADAS="${GRUPO}/inst_ordenadas/"
DIR_PARQUE_INSTALADO="${GRUPO}/parque_instalado/"
DIR_MAESTROS="${MAEDIR}/"
MAESTRO_CLIENTE="cli.mae"
MAESTRO_PRODUCTO="prod.mae"

let CANT_ARCHIVOS_RECIBIDOS=0
let CANT_ARCHIVOS_ORDENADOS=0
let CANT_ARCHIVOS_DUPLICADOS=0
let CANT_BLOQUES_ANALIZADOS=0
let CANT_BLOQUES_RECHAZADOS=0
let CANT_BLOQUES_VALIDOS=0
let CANT_REGISTROS_LEIDOS=0
let CANT_REGISTROS_RECHAZADOS=0
let CANT_REGISTROS_VALIDOS=0
SUCURSAL_ID=""
}


# devuelve la informacion de log al logger
# parametro 1: mensaje
# parametro 2: tipo de mensaje
function loguear() {

$COMANDO_LOGUEART "GrabarParqueT" "$1" "$2"

}

#mueve un archivo a otro lado
# parametro 1: entrada
# parametro 2: salida
function muevo_archivos (){

loguear "I" "Mandando a mover $1 a $2."
$COMANDO_MOVERT "$1" "$2" "GrabarParqueT"

}


# mueve un archivo recibido a la carpeta de archivos rechazados
# parametro 1: archivo a rechazar
function rechazo_archivo_recibido () {   

  muevo_archivos ${DIR_INST_RECIBIDAS}$1 ${DIR_INST_RECHAZADAS}   #muevo el archivo rechazado al directorio correspondiente 
	
}

# mueve un archivo recibido a la carpeta de archivos procesados
# parametro 1: archivo ya procesado
function muevo_archivo_procesado()
{
	muevo_archivos ${DIR_INST_RECIBIDAS}$1 ${DIR_INST_PROCESADAS}   #muevo el archivo procesado al directorio correspondiente 
}


# Ordena un archivo recibido, el ordenado lo guarda en la carpeta de inst ordenadas.
# parametro 1: archivo ya procesado
function order_archivo_recibido()
{
	
	sort -t , -k 1,1n -k 2,2 -k 3,3n -k 5,5r ${DIR_INST_RECIBIDAS}$1> ${DIR_INST_ORDENADAS}$1
	loguear "I" "Se ha ordenado el archivo $1."
}


#Verifica si sobran o faltan campos
#$1 registro
#devuelve 1 si faltan campos
#devuelve 0 si no faltan campos
#devuelve 2 si sobran
function masMenosCampos()
{
	LINEA=$1
	ULTIMO_REGISTRO=`echo "$LINEA" | cut -f6 -d ','| grep -c "$REGEX_DECIMAL"`
	SOBRA_REGISTRO=`echo "$LINEA" | cut -f7 -d ','| grep -c "."`
	
	if [ ${ULTIMO_REGISTRO} -eq 0 ]
         then
		return 1 #faltan campos
	fi
    	
	if [ ${SOBRA_REGISTRO} -eq 1 ]
         then
		return 2 # sobran campos
	else
		return 0 #campos correctos
	fi
}


#Notifica cual es el campo no informado
#$1 registro
#devuelve un numero del 1 al 6 indicando que campo falta
#devuelve 0 si todos los campos estan llenos
function faltaCampo()
{
	LINEA=$1
	FALTA_CUSTOMER_ID=`echo "$LINEA" | cut -f1 -d ','| grep -c "."`
	FALTA_OPERATION_DATE=`echo "$LINEA" | cut -f2 -d ','| grep -c "."`
	FALTA_COMMERCIAL_PLAN_ID=`echo "$LINEA" | cut -f3 -d ','| grep -c "."`
	FALTA_CLASS_SERVICE_ID=`echo "$LINEA" | cut -f4 -d ','| grep -c "."`
	FALTA_CLASS_SERVICE_IS_REQUIRED=`echo "$LINEA" | cut -f5 -d ','| grep -c "."`
	FALTA_ITEM_ID=`echo "$LINEA" | cut -f6 -d ','| grep -c "."`

        
	if [ ${FALTA_CUSTOMER_ID} -eq 0 ]
	then
		return 1	
	fi

	if [ ${FALTA_OPERATION_DATE} -eq 0 ]
	then
		return 2		
	fi
	if [ ${FALTA_COMMERCIAL_PLAN_ID} -eq 0 ]
	then	
		return 3	
	fi	
	if [ ${FALTA_CLASS_SERVICE_ID} -eq 0 ]
	then
		return 4	
	fi
	if [ ${FALTA_CLASS_SERVICE_IS_REQUIRED} -eq 0 ]
	then
		return 5	
	fi
	if [ ${FALTA_ITEM_ID} -eq 0 ]
	then
		return 6	
	fi
	
 return 0
}


#Agrega un registro al archivo de rechazados
#$1 NOMBRE DEL ARCHIVO
function agregarRegistroRechazado()
{
	if [ ! -e "${DIR_INST_RECHAZADAS}$1" ]  #verifico que el archivo exista

	  then
	    touch ${DIR_INST_RECHAZADAS}$1   #creo el archivo
	fi

	#armo registro

	FECHA=`date +%D`
	HORA=`date +%R`
	MOTIVO_DE_RECHAZO=$2
	REGISTRO_ORIGINAL=$3
	loguear "A" "Se rechaza el bloque. Motivo: $2."
	echo "$FECHA $HORA-${MOTIVO_DE_RECHAZO}-${REGISTRO_ORIGINAL}" >> ${DIR_INST_RECHAZADAS}$1  #agrego la linea al archivo

}

#agrega un registro al archivo de parque instalado
#$1 NOMBRE DEL ARCHIVO
#$2 ID DE SUCURSAL
#$3 ID DE CLIENTE
#$4 ITEM NAME DE CABECERA
#$5 ITEM NAME DE DETALLE
function agregarRegistroInstalado()
{
        
	if [ ! -e "${DIR_PARQUE_INSTALADO}$1" ]  #verifico que el archivo exista
	  then
	    touch ${DIR_PARQUE_INSTALADO}$1   #creo el archivo
	fi

	#armo registro

	ID_SUCURSAL=$2
	ID_CLIENTE=$3
	ITEM_NAME_CABECERA=$4
	ITEM_NAME_DETALLE=$5

	echo "${ID_SUCURSAL},${ID_CLIENTE},${ITEM_NAME_CABECERA},${ITEM_NAME_DETALLE}" >> ${DIR_PARQUE_INSTALADO}$1  #agrego la linea al archivo
	loguear "I" "Agrego registro del cliente ${ID_CLIENTE} al parque Instalado por sucursal ${ID_SUCURSAL}."
}


#Llama al metodo agregarRegistroRechazado en el caso de que
#falten campos o sobren.
#$1:resultado del metodo masMenosCampos
#$2:nombre del archivo
#$3:registro completo
function rechazoPorCamposGeneral()
{
        CANT_CAMPOS=$1

	case ${CANT_CAMPOS} in
      		1) agregarRegistroRechazado $2 "Campos Faltantes" $3;;
      		2) agregarRegistroRechazado $2 "Campos excedentes" $3;;
	esac
}


#Llama al metodo agregarRegistroRechazado en el caso de que
#un campo no haya sido informado.
#$1:resultado del metodo faltaCampo
#$2:nombre del archivo
#$3:registro completo
function rechazoPorCampoParticular()
{
	CAMPO_NO_INFORMADO=$1

	case ${CAMPO_NO_INFORMADO} in
      		1) agregarRegistroRechazado $2 "Campo CUSTOMER no iformado" $3 ;;
      		2) agregarRegistroRechazado $2 "Campo OPERATION_DATE no iformado" $3;;
      		3) agregarRegistroRechazado $2 "Campo COMMERCIAL_PLAN_ID no iformado" $3;;
      		4) agregarRegistroRechazado $2 "Campo CLASS_SERVICE_ID no iformado" $3;;
		5) agregarRegistroRechazado $2 "Campo CLASS_SERVICE_IS_REQUIRED no iformado" $3;;
		6) agregarRegistroRechazado $2 "Campo ITEM_ID no iformado" $3;;

 	 esac


}


#verifica si existe el id de cliente a consultar
#$1 registro
#devuelve 0 si existe
#devuelve 1 si no existe
function existeCliente() 
{
	IDCliente=`echo "$1" | cut -f1 -d ','` 
		
	archivo_maestro=${DIR_MAESTROS}${MAESTRO_CLIENTE}

	result=$(awk -v idCliente="$IDCliente" 'BEGIN { FS = ";" };
	{ 
		if(idCliente == $1)
		{
			# Cliente encontrado
			print "ok"
			exit 0
		}
	};' "$archivo_maestro")

	if [ -z "$result" ]
	then
		loguear "A" "El cliente con ID $IDCliente no existe."
		return 1
	else
		# Cliente encontrado
		return 0
	fi
}


#verifica si la fecha del registro es valida
#$1: registro
# devuelve 1 si la fecha es invalida
function fecha_invalida(){

FECHA=`echo "$1" | cut -f2 -d ','` 

panio=`echo $FECHA | cut -d"-" -f1 | grep "^[0-9]*$"`
if [ -z "$panio" ]
then
	loguear "A" "La fecha del registro es invalida."
    return 1
fi
panioActual=$(date -u '+%Y')

if [ $panio -lt $panioActual ]
then 
	loguear "A" "La fecha del registro no pertenece al año vigente."
	return 1 #es del año pasado
else
	FECHA_PARAMETRO=$(date -u -d "$FECHA" '+%s')  #tomo la fecha por parametro y la paso a segundos 
	FECHA_ACTUAL=$(date -u -d "`date -u '+%Y-%m-%d'`" '+%s') #primero tomo la fecha de hoy sin contar los segundos y despues convierto,

	((dif=$FECHA_ACTUAL-$FECHA_PARAMETRO))

	if [ $dif -gt 0 ]
	  then
	    return 0
	  else
		loguear "A" "La fecha del registro es invalida."
	    return 1
	fi
fi

}


#verifica si el producto es valido
#$1 registro
#devuelve 1 si es un producto valido
function producto_valido()
{
	REGISTRO="$1"
	COMMERCIAL_PLAN_ID=`echo "$REGISTRO" | cut -f3 -d ','`
	CLASS_SERVICE_ID=`echo "$REGISTRO" | cut -f4 -d ','`
	ITEM_ID=`echo "$REGISTRO" | cut -f6 -d ','`


	TERNA_REGISTRO="${COMMERCIAL_PLAN_ID}-${CLASS_SERVICE_ID}-${ITEM_ID}"
	archivo_maestro=${DIR_MAESTROS}${MAESTRO_PRODUCTO}


	MACHEOSPRODUCTO=`cat ${archivo_maestro} | grep -Ei "^[0-9]+,[a-z]+,${COMMERCIAL_PLAN_ID}+,(.*)+,${CLASS_SERVICE_ID}+,(.*)+,(.*)+,${ITEM_ID}+,*"`
	
	if [ "${MACHEOSPRODUCTO}" != "" ]
        then
   		#GUARDO EL ITEM_NAME
		ITEM_NAME=`echo $MACHEOSPRODUCTO | cut -d"," -f9`
		return 1
        fi
	loguear "A" "El producto del registro es invalido."	
	return 0

}

#valida cada uno de los campos de un registro bien formado
#param $1 registro cabecera
#param $2 registro detalle
#param $3 nombre del archivo
#devuelve 0 si habia campos invalidos
#devuelve 1 si los campos son validos
function validacion_por_campo()
{
	CABECERA="$1"
	DETALLE="$2"
	ARCHIVO="$3"

	fecha_invalida "$CABECERA"
	RTAFECHA=$?
	
	existeCliente "$CABECERA"
	RTACLIENTE=$?

	producto_valido "$CABECERA"
	RTAPRODUCTO_CABECERA=$?
	ITEM_NAME_CABECERA="$ITEM_NAME"

	producto_valido "$DETALLE"
 	RTAPRODUCTO_DETALLE=$?
	ITEM_NAME_DETALLE="$ITEM_NAME"

	if [ $RTACLIENTE -eq 1 ]
	 then
	 
	  agregarRegistroRechazado $ARCHIVO "Cliente inexistente" $CABECERA
	  let CANT_REGISTROS_RECHAZADOS=${CANT_REGISTROS_RECHAZADOS}+1
	  return 0
	fi
        
	if [ $RTAFECHA -eq 1 ]
	 then
	 
	  agregarRegistroRechazado $ARCHIVO "Fecha invalida" $CABECERA
          let CANT_REGISTROS_RECHAZADOS=${CANT_REGISTROS_RECHAZADOS}+1
	  return 0
	fi
	
	if [ ${RTAPRODUCTO_CABECERA} -eq 0 ]
	 then
	 
	  agregarRegistroRechazado $ARCHIVO "Producto invaldo" $CABECERA
	  let CANT_REGISTROS_RECHAZADOS=${CANT_REGISTROS_RECHAZADOS}+1
          ITEM_NAME_CABECERA=0
	  return 0
	fi
	
	if [ ${RTAPRODUCTO_DETALLE} -eq 0 ]
	 then
 	
	  agregarRegistroRechazado $ARCHIVO "Producto invaldo" $DETALLE
	  let CANT_REGISTROS_RECHAZADOS=${CANT_REGISTROS_RECHAZADOS}+1
	  ITEM_NAME_DETALLE=0
	  return 0
	fi
  return 1 #campos validos
}


#obtiene la sucursal casteando el nombre del archivo
#$1 nombre del archivo
function obtener_sucursal()
{	
#nombre=`echo $1 | cut -d"." -f1`
	SUCURSAL_ID=`echo $1 | cut -d"-" -f2`

	return 0
}


#Obtiene el product type name del commercial plan id solicitado
#$1: COMMERCIAL_PLAN_id
function obtener_product_type_name()
{
	COMMERCIAL_PLAN=$1
	
	archivo_maestro=${DIR_MAESTROS}${MAESTRO_PRODUCTO}

	MACHEOS_PRODUCTO=`cat ${archivo_maestro} | grep -Ei "^[0-9]+,[a-z]+,${COMMERCIAL_PLAN}+,*" | head -n1`
	
	if [ "${MACHEOS_PRODUCTO}" != "" ]
		then
	   		#GUARDO EL PRODUCT_TYPE_NAME
			PRODUCT_TYPE_NAME=`echo ${MACHEOS_PRODUCTO} | cut -d"," -f2`
			return 1
		fi

	return 0
}


#Agrega un registro al archivo de parque instalado
#$1 registro cabecera
#$2 registro detalle
#$3 nombre archivo
function agregar_parque_instalado()
{
	CABECERA=$1
	DETALLE=$2
	ARCHIVO=$3

	COMMERCIAL_PLAN_ID=`echo "$CABECERA" | cut -f3 -d ','` 
	CLIENTE_ID=`echo "$CABECERA" | cut -f1 -d ','` 

	obtener_sucursal $ARCHIVO
	
	obtener_product_type_name $COMMERCIAL_PLAN_ID
        
	case ${PRODUCT_TYPE_NAME} in
      		INTERNETCABLEMODEM) agregarRegistroInstalado "INTERNETCABLEMODEM" ${SUCURSAL_ID} ${CLIENTE_ID} "${ITEM_NAME_CABECERA}" "${ITEM_NAME_DETALLE}";;
      		TVPORCABLE) agregarRegistroInstalado "TVPORCABLE" ${SUCURSAL_ID} ${CLIENTE_ID} "${ITEM_NAME_CABECERA}" "${ITEM_NAME_DETALLE}";;
      		TVPORAIRE) agregarRegistroInstalado "TVPORAIRE" ${SUCURSAL_ID} ${CLIENTE_ID} "${ITEM_NAME_CABECERA}" "${ITEM_NAME_DETALLE}";;
      		INTERNETADSL) agregarRegistroInstalado "INTERNETADSL" ${SUCURSAL_ID} ${CLIENTE_ID} "${ITEM_NAME_CABECERA}" "${ITEM_NAME_DETALLE}";;
		INTERNETINALAMBRICO) agregarRegistroInstalado "INTERNETINALAMBRICO" ${SUCURSAL_ID} ${CLIENTE_ID} "${ITEM_NAME_CABECERA}" "${ITEM_NAME_DETALLE}";;
		INTERNETDIALUP) agregarRegistroInstalado "INTERNETDIALUP" ${SUCURSAL_ID} ${CLIENTE_ID} "${ITEM_NAME_CABECERA}" "${ITEM_NAME_DETALLE}";;

 	 esac	


}


#######------ Fin de deficiones de Funciones------#######





####### ---- Proceso Principal -----#######



if [ -z $GRUPO ]  # si no esta cargada la variable de grupo
  then
	echo "no se ha detectado la variable de ambiente con el path ni se ha especificado por parámetro, abortando"
	exit 2
  else
	inicializo_variables
fi



#######----------- verifico que no haya otra instancia de GrabarParqueT-----########
INSTANCIAS=`ps -e | grep -c GrabarParqueT.sh` # me devuelve la cantidad de procesos en ejecucion que contengas GrabarParqueT

if [ ${INSTANCIAS} -gt 2 ]   #si es mayor que 2, porque contabilizo la actual
  then
    loguear "A" "Existe otra instancia de GrabarParqueT" 
    exit 1
fi

########------------Fin verificacion de instancias-------------#########


#######----------- verificacion de ambiente-----########

#verifico que los directorios existan
if [ ! -d $DIR_INST_RECIBIDAS ]; then
  loguear "A" "El directorio $DIR_INST_RECIBIDAS no existe."
  loguear "SE" 9
exit 0
fi


if [ ! -d $DIR_INST_PROCESADAS ]; then
  loguear "A" "el directorio $DIR_INST_PROCESADAS no existe"
  loguear "SE" 9
exit 0
fi

if [ ! -d $DIR_INST_RECHAZADAS ]; then
  loguear "A" "el directorio $DIR_INST_RECHAZADAS no existe."
  loguear "SE" 9
exit 0
fi

if [ ! -d $DIR_INST_ORDENADAS ]; then
  loguear "A" "el directorio $DIR_INST_ORDENADAS no existe."
  loguear "SE" 9
exit 0
fi

if [ ! -d $DIR_PARQUE_INSTALADO ]; then
  loguear "A" "El directorio $DIR_PARQUE_INSTALADO no existe."
  loguear "SE" 9
exit 0
fi

if [ ! -d $DIR_MAESTROS ]; then
  loguear "A" "el directorio $DIR_MAESTROS no existe."
  loguear "SE" 9
exit 0
fi


#######----------- FIN verificacion de ambiente-----########





#######----------- Inicializo Log-----########

loguear "I" "Iniciando GrabarParqueT: `ls ${DIR_INST_RECIBIDAS} -l | grep -c '^-'`"   # ls -l | grep -c '^-'  devuelve la cantidad de archivos regulares en la carpeta

#######----------- FIN inicio log-----########



#######----------- Inicio procesamiento-----########

# si no hay mas archivos que procesar salgo del programa
CANT_ARCHIVOS_RECIBIDOS=`find "$DIR_INST_RECIBIDAS" -maxdepth 1 -type f | wc -l`



if [ $CANT_ARCHIVOS_RECIBIDOS -eq 0 ]
then
	loguear "I" "No hay mas archivos que procesar."
	exit 0
fi


#cd ${DIR_INST_RECIBIDAS} # me muevo al directorio de instalaciones recibidas


for archiv in `find "$DIR_INST_RECIBIDAS" -maxdepth 1 -type f`; do
	archivo="${archiv##*/}"
	loguear "I" "Archivo a procesar: ${archivo}"
	
	versionado=`echo $archivo | grep -c '\.'`
	if [ $versionado -eq 1 ]
    then
		loguear "A" "Archivo a procesar duplicado Versionado: ${archivo} , moviendo a Rechazados"
		loguear "E" 1
	    rechazo_archivo_recibido "${archivo}"  #muevo el archivo desde el directorio DE recibidas hasta el de rechazados
	    let CANT_ARCHIVOS_DUPLICADOS=${CANT_ARCHIVOS_DUPLICADOS}+1
	    continue
	fi
	###### ------Verifico archivos duplicados-----######
	if [ -e "${DIR_INST_PROCESADAS}${archivo}" ]    #pregunto si el archivo ya existe, en cuyo caso es duplicado
	then
		###### ------Es duplicado -----######
		loguear "A" "Archivo a procesar dulplicado: ${archivo} , moviendo a Rechazados"
		loguear "E" 1
		rechazo_archivo_recibido "${archivo}"  #muevo el archivo desde el directorio DE recibidas hasta el de rechazados
		let CANT_ARCHIVOS_DUPLICADOS=${CANT_ARCHIVOS_DUPLICADOS}+1
	else
		###### ------No es duplicado -----######
		#ORDENO ARCHIVO Y LO GUARDO EN CARPETA DE ORDENADOS		
		order_archivo_recibido  "${archivo}"
		let CANT_ARCHIVOS_ORDENADOS=${CANT_ARCHIVOS_ORDENADOS}+1
		muevo_archivo_procesado "${archivo}"


		cabecera='0'
		detalle=0
		buscarDetalle=0
		IDC=0
		IDCR=0
		#####----- Comienzo el procesamiento del archivo-----#######
		for RENGLON in `cat ${DIR_INST_ORDENADAS}${archivo}` ; do    # PARA CADA RENLGON DE LA FACTURA
		    #####################################
		    #COMIENZA CHEQUEOS A NIVEL DE BLOQUE#
		    #####################################

		    #OBTENGO UNA CABECERA Y LA ANALIZO
		    if [ "$cabecera" = '0' ] 
		    then
				cabecera="$RENGLON"
				let CANT_BLOQUES_ANALIZADOS=${CANT_BLOQUES_ANALIZADOS}+1
				#obtengo el Customer_id
				IDC=`echo "$cabecera" | cut -f1 -d ',' | grep "^[0-9]*$"`
				if [ -z "$IDC" ]
				then
					IDC=0
				fi
			
				if [ $IDCR -ne $IDC ] 
				then
					#SI ES CABECERA DEBE TENER UNA "Y" EN EL CAMPO 5
					okCabecera=`echo "$cabecera" | cut -f5 -d ','`
				
					if [ "$okCabecera" == "Y" ] 
					then
						#ES CABECERA, VOY A BUSCAR SU DETALLE
						buscarDetalle=1
					else 
						#SI NO ES CABECERA
						
						#RECHAZO EL BLOQUE
						agregarRegistroRechazado "${archivo}" "Falta de registro cabecera" "$cabecera"
						let CANT_BLOQUES_RECHAZADOS=${CANT_BLOQUES_RECHAZADOS}+1
						IDCR=$IDC
						cabecera='0' #BUSCO NUEVA CABECERA
						buscarDetalle=1
					fi
				else
					#ES EL DETALLE DE LA ULTIMA CABECERA RECHAZADA
					cabecera='0'
					buscarDetalle=1
				fi
		    fi
	
		    #OBTENGO DETALLE O NUEVA CABECERA
		    if [ $buscarDetalle -eq 1 ]
		    then
				buscarDetalle=0
				#BUSCO EL DETALLE. SI CABECERA=0, BUSCO NUEVA CABECERA
				continue
			else
				#YA TENGO EL DETALLE
				detalle="$RENGLON"
				
				IDD=`echo "$detalle" | cut -f1 -d ',' | grep "^[0-9]*$"` 
				if [ -z "$IDD" ]
				then
					IDD=0
				fi

				#CHEQUEO EL ID DE LA CABECERA CON EL ID DEL DETALLE
				if [ $IDC -eq $IDD ]
				then
					#TIENEN IGUAL ID
					#VERIFICO QUE TENGA CARACTERISTICAS DE DETALLE
					okDetalle=`echo "$detalle" | cut -f5 -d ','`
					if [ "$okDetalle" == "N" ]
					then
					
						#CHEQUEOS A NIVEL DE BLOQUE TERMINADOS
					
						let CANT_BLOQUES_VALIDOS=${CANT_BLOQUES_VALIDOS}+1

						########################################
						#COMIENZA CHEQUEOS A NIVEL DE REGISTROS#
						########################################

						#VERIFICO QUE EXISTAN TODOS LOS CAMPOS Y ESTEN CORRECTAMENTE FORMADOS
						REGEX_CABECERA_DETALLE="^$REGEX_DECIMAL,$REGEX_FECHA,$REGEX_DECIMAL,$REGEX_DECIMAL,[[:alpha:]],$REGEX_DECIMAL$"
				
						MACHEOSCABECERA=`echo $cabecera | grep -c $REGEX_CABECERA_DETALLE`
						let CANT_REGISTROS_LEIDOS=${CANT_REGISTROS_LEIDOS}+1
						#VERIFICO SI MACHEA CABECERA
					    if [ $MACHEOSCABECERA -eq 0 ]
						then
							#NO MACHEO CABECERA
							#VERIFICO SI FALTAN CAMPOS O SOBRAN
							let CANT_REGISTROS_RECHAZADOS=${CANT_REGISTROS_RECHAZADOS}+1	
							masMenosCampos "$cabecera"
							rta_masMenosCampos=$?
							#INSERTO EN RECHAZADOS SI SOBRAN O FALTAN	
							rechazoPorCamposGeneral ${rta_masMenosCampos} "${archivo}" "${cabecera}"

							#SI ESTAN TODOS LOS CAMPOS, VERIFICO CUAL FUE NO INFORMADO
							if [ ${rta_masMenosCampos} -eq 0 ]
							then
								faltaCampo "$cabecera"
								rta_faltaCampo=$?
								#INSERTO EN RECHAZADOS
								rechazoPorCampoParticular ${rta_faltaCampo} "${archivo}" "${cabecera}"
							fi	
							cabecera='0'
							continue #CONTINUO CON EL PROXIMO REGISTRO
						else
							#MACHEA CABECERA
							#VERIFICO DETALLE
							

							MACHEOSDETALLE=`echo $detalle | grep -c $REGEX_CABECERA_DETALLE`
							let CANT_REGISTROS_LEIDOS=${CANT_REGISTROS_LEIDOS}+1
							if [ $MACHEOSDETALLE -eq 0 ]
							then
								#NO MACHEO DETALLE
								#VERIFICO SI FALTAN CAMPOS O SOBRAN
								
								let CANT_REGISTROS_RECHAZADOS=${CANT_REGISTROS_RECHAZADOS}+1	
								masMenosCampos "$detalle"
								rta_masMenosCampos=$?
								#INSERTO EN RECHAZADOS SI SOBRAN O FALTAN	
								rechazoPorCamposGeneral ${rta_masMenosCampos} "${archivo}" "${detalle}"
								
								#SI ESTAN TODOS LOS CAMPOS, VERIFICO CUAL FUE NO INFORMADO
								if [ ${rta_masMenosCampos} -eq 0 ]
								then
									faltaCampo "$detalle"
									rta_faltaCampo=$?
									#INSERTO EN RECHAZADOS
									rechazoPorCampoParticular ${rta_faltaCampo} "${archivo}" "${detalle}"
								fi
								cabecera='0'	
								continue #CONTINUO CON EL PROXIMO REGISTRO
						
							else
								#MACHEA DETALLE
								#####################################
								#COMIENZA CHEQUEOS A NIVEL DE CAMPOS#
								#####################################

								validacion_por_campo "${cabecera}" "${detalle}" "${archivo}"
								rta_validacion_por_campo=$?
								if [ ${rta_validacion_por_campo} -eq 1 ]
								then
									
									#EL BLOQUE ES TOTALMENTE VALIDO = 2 registros validos
									let CANT_REGISTROS_VALIDOS=${CANT_REGISTROS_VALIDOS}+2
									agregar_parque_instalado "$cabecera" "$detalle" "$archivo"
								fi
								cabecera='0'
								continue	
							fi
				
					    fi
						cabecera='0'
						continue
				    else
						#ES UN DETALLE MAL FORMADO. NO TIENE LA "N"
						
						agregarRegistroRechazado "${archivo}" "Falta de registro detalle" "${cabecera}+${detalle}"
						let CANT_BLOQUES_RECHAZADOS=${CANT_BLOQUES_RECHAZADOS}+1
						cabecera='0'
					fi
				else
					#EL DETALLE TIENE DISTINTO ID QUE LA ULTIMA CABECERA
				
					agregarRegistroRechazado "${archivo}" "Falta de registro detalle" "${cabecera}"
			        let CANT_BLOQUES_RECHAZADOS=${CANT_BLOQUES_RECHAZADOS}+1
		
					#AHORA LA CABECERA ES EL ULTIMO DETALLE
			    	cabecera=$detalle
					let CANT_BLOQUES_ANALIZADOS=${CANT_BLOQUES_ANALIZADOS}+1
				
					IDC=`echo "$cabecera" | cut -f1 -d ',' | grep "^[0-9]*$"`
					if [ -z "$IDC" ]
					then
						IDC=0
					fi
					#VERIFICO SI ES CABECERA
					okCabecera=`echo $cabecera | cut -f1 -d ','`
						
					if [ "$okCabecera" == "Y" ]
					then 
						#ES CABECERA. BUSCO EN EL PROXIMO REGISTRO SU DETALLE					
						buscarDetalle=0
					else 
						#NO ES CABECERA.
						agregarRegistroRechazado "${archivo}" "Falta de registro Cabecera" "${cabecera}"
						let CANT_BLOQUES_RECHAZADOS=${CANT_BLOQUES_RECHAZADOS}+1
						cabecera='0'
					fi
				fi
		    fi
		done
	fi
done

loguear "I" "Cantidad de archivos leidos de inst_recibidas: ${CANT_ARCHIVOS_RECIBIDOS}"
loguear "I" "Cantidad de archivos ordenados: ${CANT_ARCHIVOS_ORDENADOS}"
loguear "I" "Cantidad de archivos rechazados por duplicados: ${CANT_ARCHIVOS_DUPLICADOS}"
loguear "I" "Cantidad de bloques analizados: ${CANT_BLOQUES_ANALIZADOS}"
loguear "I" "Cantidad de bloques rechazados: ${CANT_BLOQUES_RECHAZADOS}"
loguear "I" "Cantidad de bloques validos: ${CANT_BLOQUES_VALIDOS}"
loguear "I" "Cantidad de registros leidos de bloques validos: ${CANT_REGISTROS_LEIDOS}"
loguear "I" "Cantidad de registros rechazados de bloques validos: ${CANT_REGISTROS_RECHAZADOS}"
loguear "I" "Cantidad de registros de bloques validos insertados en parque de instalaciones: ${CANT_REGISTROS_VALIDOS}"
let TOTAL_CONTROL=${CANT_REGISTROS_RECHAZADOS}+${CANT_REGISTROS_VALIDOS}
loguear "I" "Total de control: ${TOTAL_CONTROL}"
exit 0
